#!/usr/bin/python2.5
# -*- coding: iso-8859-1 -*-

from Tkinter import *
from turtle import *
from math import *
from random import *
from csv import *
from tkMessageBox import *


global kddcupContinuousNames
kddcupContinuousNames = [\
                        'duration',
                        'src_bytes',
                        'dst_bytes', \
                        'wrong_fragment', \
                        'urgent', \
                        'hot', \
                        'num_failed_logins', \
                        'num_compromised', \
                        #'root_shell', \
                        #'su_attempted', \
                        'num_root', \
                        'num_file_creations', \
                        'num_shells', \
                        'num_access_files', \
                        'num_outbound_cmds', \
                        'count', \
                        'srv_count', \
                        'serror_rate', \
                        'srv_serror_rate', \
                        'same_srv_rate', \
                        'rerror_rate', \
                        'srv_rerror_rate', \
                        'diff_srv_rate', \
                        'srv_diff_host_rate', \
                        'dst_host_count', \
                        'dst_host_srv_count', \
                        'dst_host_same_srv_rate', \
                        'dst_host_diff_srv_rate', \
                        'dst_host_same_src_port_rate', \
                        'dst_host_srv_diff_host_rate', \
                        'dst_host_serror_rate', \
                        'dst_host_srv_serror_rate', \
                        'dst_host_rerror_rate', \
                        'dst_host_srv_rerror_rate']

#global wektorSrednich
#wektorSrednich = [0.0 for i in range(len(kddcupContinuousNames))]


class Anomaly:

    def __init__(self, master=None):
        self.master = master
        self.frame = Frame(master, name="frame")
        self.frame.master.title("Anomaly")
        self.frame.pack(expand=1, fill=BOTH)

        self.subframe0 = Frame(self.frame, name="subframe0")
        self.subframe0.pack(expand=1, fill=BOTH)

        self.subframe0.vscroll = Scrollbar(self.subframe0, orient=VERTICAL)
        self.subframe0.hscroll = Scrollbar(self.subframe0, orient=HORIZONTAL)
        #self.subframe0.plotno = ScrolledCanvas(self.frame, height=1250, width=1250, scrollregion=(0,0,10000,102000))
        self.subframe0.plotno = Canvas(self.subframe0, bg='white', xscrollcommand=self.subframe0.hscroll.set, yscrollcommand=self.subframe0.vscroll.set)

        self.subframe0.hscroll['command'] = self.subframe0.plotno.xview
        self.subframe0.vscroll['command'] = self.subframe0.plotno.yview
        self.subframe0.hscroll.pack(side=BOTTOM, fill=X)
        self.subframe0.vscroll.pack(side=RIGHT, fill=Y)
        self.subframe0.plotno.pack(expand=1, fill=BOTH)
        self.subframe0.plotno.config(scrollregion=self.subframe0.plotno.bbox(ALL))

        self.subframe1 = Frame(self.frame, name="subframe1")
        self.subframe1.pack(expand=0, fill=X)

        self.subframe2 = Frame(self.frame, name="subframe2")
        self.subframe2.pack(expand=0, fill=X)

        self.Kontrolki()


    def Kontrolki(self):


        self.uczaceLabel = Label(self.subframe1, text = ' dane uczace ', width=13)
        self.uczaceLabel.pack(side=LEFT)
        self.uczaceEntry = Entry(self.subframe1, relief=SUNKEN, width=40, bg='white')
        self.uczaceEntry.pack(side=LEFT)

        self.doAnalizyLabel = Label(self.subframe2, text = ' dane do analizy ', width=13)
        self.doAnalizyLabel.pack(side=LEFT)
        self.doAnalizyEntry = Entry(self.subframe2, relief=SUNKEN, width=40, bg='white')
        self.doAnalizyEntry.pack(side=LEFT)

        self.chiButton = Button(self.subframe2, text = 'test Chi-kwadrat', width=13, bg='blue', fg='white', command=self.przedzialChi)
        self.chiButton.pack(side=LEFT)

        self.studentButton = Button(self.subframe2, text = 'test T-Studenta', width=13, bg='blue', fg='white', command=self.przedzialT)
        self.studentButton.pack(side=LEFT)

        #self.przedzialTButton = Button(self.subframe1, text = 'przedzial ufnosci dla odleglosci T', width=25, bg='blue', fg='white', command=self.zaznaczPrzedzialT)
        #self.przedzialTButton.pack(side=LEFT)

        #self.przedzialChiButton = Button(self.subframe1, text = 'przedzial ufnosci dla odleglosci Chi', width=25, bg='blue', fg='white', command=self.zaznaczPrzedzialChi)
        #self.przedzialChiButton.pack(side=LEFT)

        self.czyscButton = Button(self.subframe2, text = 'czysc', width=6, bg='blue', fg='white', command=self.czysc)
        self.czyscButton.pack(side=LEFT)

        self.koniecButton = Button(self.subframe2, text = 'koniec', width=6, bg='blue', fg='white', command=self.master.quit)
        self.koniecButton.pack(side=LEFT)

    def czysc(self):

        self.subframe0.plotno.delete("all")

    def testT(self, wektorSrednich, p):

        plik = self.doAnalizyEntry.get().strip()

        try:
            in_stream = open(plik, 'r')
        except:
            showwarning("Ostrzezenie!", "Zle zrodlo danych uczacych!\nWprowadz ponownie.")

        czytaj = DictReader(in_stream, delimiter = ',')

        wektorSrednich = [0.0 for i in range(len(kddcupContinuousNames))]
        k = 0
        for pole in kddcupContinuousNames:
            r = 0
            for rekord in czytaj:
                r += 1
                if float(max(rekord[pole])) != 0.0:
                    wektorSrednich[k] += float(rekord[pole])/float(max(rekord[pole]))
                    #wektorSrednich[k] += float(rekord[pole])
                else:
                    wektorSrednich[k] += float(rekord[pole])
            in_stream = open(plik, 'r')
            czytaj = DictReader(in_stream, delimiter = ',')
            wektorSrednich[k] /= float(r)
            k += 1


        self.testT = RawPen(self.subframe0.plotno)
        self.testT.color=("green")
        self.testT.tracer(0)
        self.testT.up()


        estMacierzyKowariancji = 0.0
        s = 0
        for rekord in czytaj:
            k = 0
            suma = 0.0
            for pole in kddcupContinuousNames:
                if float(max(rekord[pole])) != 0.0:
                    suma += (float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2
                    #suma += (float(rekord[pole]) - wektorSrednich[k])**2
                else:
                    suma += (float(rekord[pole]) - wektorSrednich[k])**2
                k += 1
            estMacierzyKowariancji += suma
            s += 1
        estMacierzyKowariancji /= float(s-1)


        in_stream = open(plik, 'r')
        czytaj = DictReader(in_stream, delimiter = ',')
        podzialkaX = 0
        i = 0
        #n = s
        #p = len(kddcupContinuousNames)
        #wsp = n*(n-p)/float(p*(n+1)*(n-1))
        for rekord in czytaj:
            odlegloscT = 0.0
            k = 0
            for pole in kddcupContinuousNames:
                if float(max(rekord[pole])) != 0.0:
                    odlegloscT += (float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2
                    #odlegloscT += (float(rekord[pole]) - wektorSrednich[k])**2
                else:
                    odlegloscT += (float(rekord[pole]) - wektorSrednich[k])**2
                k += 1
            if estMacierzyKowariancji != 0:
                odlegloscT /= float(estMacierzyKowariancji)
            #odlegloscT *= wsp
            self.testT.goto(podzialkaX, odlegloscT*10)
            print odlegloscT
            podzialkaX += 50
            self.testT.down()
            i += 1
            napis = str(i) + '\n' + rekord['signature'][:5]
            self.testT.write(napis)

        self.testT.speed("fastest")

        in_stream.close

        self.testT.color=("yellow")
        self.testT.tracer(0)
        self.testT.up()
        self.testT.goto(0, p*10)
        self.testT.down()
        self.testT.goto(podzialkaX, p*10)
        self.testT.speed("fastest")


    def testChi(self, wektorSrednich, wektorWariancji, p):

        plik = self.doAnalizyEntry.get().strip()

        try:
            in_stream = open(plik, 'r')
        except:
            showwarning("Ostrzezenie!", "Zle zrodlo danych uczacych!\nWprowadz ponownie.")

        czytaj = DictReader(in_stream, delimiter = ',')

        wektorSrednich = [0.0 for i in range(len(kddcupContinuousNames))]
        k = 0
        for pole in kddcupContinuousNames:
            r = 0
            for rekord in czytaj:
                r += 1
                if float(max(rekord[pole])) != 0.0:
                    wektorSrednich[k] += float(rekord[pole])/float(max(rekord[pole]))
                else:
                    wektorSrednich[k] += float(rekord[pole])
            in_stream = open(plik, 'r')
            czytaj = DictReader(in_stream, delimiter = ',')
            wektorSrednich[k] /= float(r)
            k += 1


        self.testChi = RawPen(self.subframe0.plotno)
        self.testChi.color=("blue")
        self.testChi.tracer(0)
        self.testChi.up()

        podzialkaX = 0
        i = 0
        for rekord in czytaj:
            odlegloscChi = 0.0
            k = 0
            for pole in kddcupContinuousNames:
                if wektorWariancji[k] != 0:
                    if float(max(rekord[pole])) != 0.0:
                        odlegloscChi += ((float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2)/float(wektorWariancji[k])
                    else:
                        odlegloscChi += ((float(rekord[pole]) - wektorSrednich[k])**2)/float(wektorWariancji[k])
                k += 1
            self.testChi.goto(podzialkaX, odlegloscChi)
            print odlegloscChi
            podzialkaX += 50
            self.testChi.down()
            i += 1
            napis = str(i) + '\n' + rekord['signature'][:5]
            self.testChi.write(napis)

        self.testChi.speed("fastest")

        in_stream.close

        self.testChi.color=("red")
        self.testChi.tracer(0)
        self.testChi.up()
        self.testChi.goto(0, p)
        self.testChi.down()
        self.testChi.goto(podzialkaX, p)
        self.testChi.speed("fastest")



    def przedzialChi(self):

        plik = self.uczaceEntry.get().strip()

        try:
            in_stream = open(plik, 'r')
        except:
            showwarning("Ostrzezenie!", "Zle zrodlo danych uczacych!\nWprowadz ponownie.")

        czytaj = DictReader(in_stream, delimiter = ',')

        wektorSrednich = [0.0 for i in range(len(kddcupContinuousNames))]
        k = 0
        for pole in kddcupContinuousNames:
            r = 0
            for rekord in czytaj:
                r += 1
                if float(max(rekord[pole])) != 0.0:
                    wektorSrednich[k] += float(rekord[pole])/float(max(rekord[pole]))
                else:
                    wektorSrednich[k] += float(rekord[pole])
            in_stream = open(plik, 'r')
            czytaj = DictReader(in_stream, delimiter = ',')
            wektorSrednich[k] /= float(r)
            k += 1

        #print wektorSrednich

        wektorWariancji = [0.0 for i in range(len(kddcupContinuousNames))]
        k = 0
        for pole in kddcupContinuousNames:
            r = 0
            for rekord in czytaj:
                r += 1
                if float(max(rekord[pole])) != 0.0:
                    wektorWariancji[k] += (float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2
                else:
                    wektorWariancji[k] += (float(rekord[pole]) - wektorSrednich[k])**2
            in_stream = open(plik, 'r')
            czytaj = DictReader(in_stream, delimiter = ',')
            wektorWariancji[k] /= float(r)
            k += 1

        listaOdleglosciChi = []
        r = 0
        for rekord in czytaj:
            odlegloscChi = 0.0
            k = 0
            for pole in kddcupContinuousNames:
                if wektorWariancji[k] != 0:
                    if float(max(rekord[pole])) != 0.0:
                        odlegloscChi += ((float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2)/float(wektorWariancji[k])
                    else:
                        odlegloscChi += ((float(rekord[pole]) - wektorSrednich[k])**2)/float(wektorWariancji[k])
                k += 1
            listaOdleglosciChi += [odlegloscChi]
            print listaOdleglosciChi[r]
            r += 1
        print '\n\n'

        #print listaOdleglosciChi

        sredniaZodleglosciChi = 0.0
        for odleglosc in listaOdleglosciChi:
            sredniaZodleglosciChi += odleglosc

        sredniaZodleglosciChi /= float(len(listaOdleglosciChi))

        #print sredniaZodleglosciChi

        estWariancji = 0.0
        for odleglosc in listaOdleglosciChi:
            estWariancji += (odleglosc - sredniaZodleglosciChi)**2

        estWariancji /= float((len(listaOdleglosciChi) - 1))

        #print estWariancji

        """self.zaznaczPrzedzialChi = RawPen(self.subframe0.plotno)
        self.zaznaczPrzedzialChi.color=("red")
        self.zaznaczPrzedzialChi.tracer(0)
        self.zaznaczPrzedzialChi.up()"""

        #p = (sredniaZodleglosciChi + 3*estWariancji)
        p = sredniaZodleglosciChi
        #p = 3*gauss(sredniaZodleglosciChi, estWariancji)

        in_stream.close

        self.testChi(wektorSrednich, wektorWariancji, p+3)

        #print '\n', p, sredniaZodleglosciChi, estWariancji, '\n'
        """self.zaznaczPrzedzialChi.goto(0, p*1000)
        self.zaznaczPrzedzialChi.down()
        self.zaznaczPrzedzialChi.goto(koniec, p*1000)
        self.zaznaczPrzedzialChi.speed("fastest")"""


    def przedzialT(self):

        plik = self.uczaceEntry.get().strip()

        try:
            in_stream = open(plik, 'r')
        except:
            showwarning("Ostrzezenie!", "Zle zrodlo danych uczacych!\nWprowadz ponownie.")

        czytaj = DictReader(in_stream, delimiter = ',')

        wektorSrednich = [0.0 for i in range(len(kddcupContinuousNames))]
        k = 0
        for pole in kddcupContinuousNames:
            r = 0
            for rekord in czytaj:
                r += 1
                if float(max(rekord[pole])) != 0.0:
                    wektorSrednich[k] += float(rekord[pole])/float(max(rekord[pole]))
                    #wektorSrednich[k] += float(rekord[pole])
                else:
                    wektorSrednich[k] += float(rekord[pole])
            in_stream = open(plik, 'r')
            czytaj = DictReader(in_stream, delimiter = ',')
            wektorSrednich[k] /= float(r)
            k += 1

        #print wektorSrednich

        estMacierzyKowariancji = 0.0
        s = 0
        for rekord in czytaj:
            k = 0
            suma = 0.0
            for pole in kddcupContinuousNames:
                if float(max(rekord[pole])) != 0.0:
                    suma += (float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2
                    #suma += (float(rekord[pole]) - wektorSrednich[k])**2
                else:
                    suma += (float(rekord[pole]) - wektorSrednich[k])**2
                k += 1
            estMacierzyKowariancji += suma
            s += 1
        estMacierzyKowariancji /= float(s-1)


        in_stream = open(plik, 'r')
        czytaj = DictReader(in_stream, delimiter = ',')
        listaOdleglosciT = []
        for rekord in czytaj:
            odlegloscT = 0.0
            k = 0
            for pole in kddcupContinuousNames:
                if float(max(rekord[pole])) != 0.0:
                    odlegloscT += (float(rekord[pole])/float(max(rekord[pole])) - wektorSrednich[k])**2
                    #odlegloscT += (float(rekord[pole]) - wektorSrednich[k])**2
                else:
                    odlegloscT += (float(rekord[pole]) - wektorSrednich[k])**2
                #print float(rekord[pole])
                k += 1
            #print odlegloscT
            if estMacierzyKowariancji != 0:
                odlegloscT /= float(estMacierzyKowariancji)
            listaOdleglosciT += [odlegloscT]

        #print listaOdleglosciT

        sredniaZodleglosciT = 0.0
        for odleglosc in listaOdleglosciT:
            sredniaZodleglosciT += odleglosc

        sredniaZodleglosciT /= float(len(listaOdleglosciT))

        #print sredniaZodleglosciT

        estWariancji = 0.0
        for odleglosc in listaOdleglosciT:
            estWariancji += (odleglosc - sredniaZodleglosciT)**2

        estWariancji /= float(len(listaOdleglosciT) - 1)

        #print estWariancji

        """self.zaznaczPrzedzialT = RawPen(self.subframe0.plotno)
        self.zaznaczPrzedzialT.color=("yellow")
        self.zaznaczPrzedzialT.tracer(0)
        self.zaznaczPrzedzialT.up()"""

        #p = (sredniaZodleglosciT + 3*estWariancji)
        p = sredniaZodleglosciT

        in_stream.close

        self.testT(wektorSrednich, p+3)

        #print '\n', p, sredniaZodleglosciT, estWariancji, '\n'
        """self.zaznaczPrzedzialT.goto(0, p*1000)
        self.zaznaczPrzedzialT.down()
        self.zaznaczPrzedzialT.goto(koniec, p*1000)
        self.zaznaczPrzedzialT.speed("fastest")"""


def main():
    root = Tk()
    nt = Anomaly(root)
    root.minsize(900, 600)
    root.mainloop()

main()
